/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 高生平
 * Date: 2025-08-28
 * Time: 18:12
 */
public class Demo {
    public static void main(String[] args) {
        //1.基本四则运算符（加减乘除模）
        int a = 20;
        int b = 10;
        System.out.println(a + b);//30
        System.out.println(a - b);//10
        System.out.println(a * b);//200
        System.out.println(a / b);//2
        System.out.println(a % b);//0 --> 模运算相当于数学中整除后的余数

        System.out.println("==========");
        int a1 = 3;
        int b1 = 2;
        System.out.println(a1 / b1);//1
        System.out.println(a1 * 1.0 / b1);//1.5
        double c1 = a1 * 1.0 / b1;
        System.out.println(c1);//1.5

        System.out.println("==========");
        System.out.println(5 / 2);//2
        System.out.println((float)5 / 2);//2.5
        System.out.println(5 / (float)2);//2.5
        System.out.println((float)(5 / 2));//2.0

        System.out.println("==========");
        //做除法和取模时，右操作数不能为0
//        int a2 = 1;
//        int b2 = 0;
//        System.out.println(a2 / b2);
        //运行结果：
        //Exception in thread "main" java.lang.ArithmeticException: / by zero
        //	at Demo.main(Demo.java:37)
        //ArithmeticException表示算术异常（异常种类的其中一种）

        System.out.println("==========");
        //%可以对double类型取模，但是没有意义，一般都是对整型取模
        System.out.println(11.5 % 2.0);//1.5

        float a3 = 11.5F;
        System.out.println(a3 % 2.0);

        System.out.println("==========");
        System.out.println(10 % 3);//1
        System.out.println(10 % -3);//1  10 / -3 = 3 ...... 1
        System.out.println(-10 % 3);//-1  -10 / 3 = -3 ...... -1
        System.out.println(-10 % -3);//-1  -10 / -3 = 3 ...... -1

        //2.增量运算符(+= -= *= %=)
        System.out.println("==========");
        int k = 1;
        k += 2;//相当于k = k + 2
        System.out.println(k);//输出3

        k -= 1;//相当于k = k - 1
        System.out.println(k);//输出2

        k *= 3;//相当于k = k * 3
        System.out.println(k);//输出6

        k /= 3;//相当于k = k / 3
        System.out.println(k);//输出2

        k %= 3;//相当于k = k % 3
        System.out.println(k);//输出2

        //注意：增量运算符在计算的时候，可以不进行强制类型转换
        double a4 = 10.4;
        int b4 = 10;
        b4 += a4;//不会报错，相当于b4 = (int) (b4 + a4)
        System.out.println(b4);
//        b4 = b4 + a4;//此时编译会报错，因为等号右边被提升为了double类型

        //3.自增/自减运算符（++ --）
        System.out.println("==========");
        int a5 = 1;
        a5++;//2
        System.out.println(a5++);//先使用a5原来的值2，a5再自增1，输出结果为2
        System.out.println(a5);//3

        ++a5;//4
        System.out.println(++a5);//a5先自增1，再使用a5的值，输出结果为5
        System.out.println(a5);//5

        //4.关系运算符
        System.out.println("==========");
        int a6 = 10;
        int b6 = 20;
        System.out.println(a6 == b6);//false
        System.out.println(a6 != b6);//true
        System.out.println(a6 < b6); //true
        System.out.println(a6 > b6); //false
        System.out.println(a6 <= b6);//true
        System.out.println(a6 >= b6);//false

        //5.逻辑运算符
        //5.1 逻辑与运算符
        System.out.println("==========");
        int a7 = 1;
        int b7 = 2;
        System.out.println(a7 == 1 && b7 == 2);//左为真，右为真，则结果为真
        System.out.println(a7 == 1 && b7 > 100);//左为真，但右为假，则结果为假
        System.out.println(a7 > 100 && b7 == 2);//左为假，右为真，则结果为假
        System.out.println(a7 > 100 && b7 > 100);//左为假，且右为假，则结果为假

        //5.2 逻辑或运算符
        System.out.println("==========");
        System.out.println(a7 == 1 || b7 == 2);//左为真，右为真，结果为真
        System.out.println(a7 == 1 || b7 > 100);//左为真，右为假，结果为真
        System.out.println(a7 > 100 || b7 == 2);//左为假，右为真，结果为真
        System.out.println(a7 > 100 || b7 > 100);//左为假，右为假，结果为假

        //5.3 逻辑非运算符
        System.out.println("==========");
        System.out.println(!(a7 == 1));//a7 == 1 为真，则 !(a7 == 1) 为假

        //5.4 短路求值
            //对于逻辑与运算符，如果左侧表达式值为false，则表达式结果一定为false，无需计算右侧表达式
            //对于逻辑或运算符，如果左侧表达式值为true，则表达式结果一定为true，无需计算右侧表达式
        System.out.println("==========");
        System.out.println(10 > 20 && 10 / 0 == 0);//false
        System.out.println(10 < 20 || 10 / 0 == 0);//true
            //& 和 | 如果表达式结果为boolean时，也表示逻辑运算，但是与 && || 相比，他们不支持短路求值
//        System.out.println(10 > 20 & 10 / 0 == 0);//程序抛出异常
//        System.out.println(10 < 20 | 10 / 0 == 0);//程序抛出异常
        //Exception in thread "main" java.lang.ArithmeticException: / by zero
        //	at Demo.main(Demo.java:131)

        //6.位运算符
        //按位与运算符 &
        System.out.println("==========");
        int a8 = 10;
        int b8 = 20;
        System.out.println(a8 & b8);
        //10的二进制：  00001010
        //20的二进制：  00010100
        //10和20按位与：00000000

        //按位或运算符 |
        System.out.println(a8 | b8);
        //10的二进制：  00001010
        //20的二进制：  00010100
        //10和20按位或：00011110（十进制为30）

        //按位取反运算符 ~
        int a9 = 0Xf;//十进制为15，
        // 二进制为   0000 0000 0000 0000 0000 0000 0000 1111,
        // 按位取放则为1111 1111 1111 1111 1111 1111 1111 0000
        // 再转方成16进制则为 fffffff0
        System.out.printf("%x\n", ~a9);//输出结果位fffffff0

        //按位异或运算符 ^
        //如果两个数字的二进制位相同，则结果位0，相异则结果为1，相当于找不同
        int a10 = 0x1;         //00000000 00000000 00000000 00000001
        int b10 = 0x2;         //00000000 00000000 00000000 00000010
        System.out.printf("%x\n", a10 ^ b10);
        //a10和b10按位异或的二进制位00000000 00000000 00000000 00000011
        //再转换十六进制，输出结果为3

        //7.移位运算符
        System.out.println("==========");
        //左移运算符 <<
        int a11 = 0x10;                                     //00000000 00000000 00000000 00010000
        System.out.printf("%x\n", a11 << 1);//左边抛弃，右边补0，00000000 00000000 00000000 00100000,十六进制为20

        //右移运算符 >>
        //右边抛弃，左边补上符号位（正数的符号位为0，负数的符号位为1）
        int a12 = 0x10;                     //00000000 00000000 00000000 00010000
        System.out.printf("%x\n", a12 >> 1);//00000000 00000000 00000000 00001000,十六进制为8
        int b12 = 0xffff0000;               //11111111 11111111 00000000 00000000
        System.out.printf("%x\n", b12 >> 1);//11111111 11111111 10000000 00000000,十六进制为ffff8000

        //无符号右移运算符 >>>
        //右边抛弃，左边补0
        int a13 = 0xffffffff;                //11111111 11111111 11111111 11111111
        System.out.printf("%x\n", a13 >>> 1);//01111111 11111111 11111111 11111111，十六进制为7fffffff

        //7.条件运算符
        //表达式1 ? 表达式2 : 表达式3
        //当表达式1的值为true时，整个表达式的值为表达式2的值
        //当表达式1的值为false时，整个表达式的值为表达式3的值
        //表达式2和表达式3的结果是要同类型的，除非能发生类型隐式类型转换
        System.out.println("==========");
        int a14 = 10;
        int b14 = 20;
        int max= a14 > b14 ? a14 : b14;
        System.out.println(max);//20
    }
}
